home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / games / IndiZone / blix / blix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  25.3 KB  |  1,073 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*__________________________________________________________________________
  18.  |
  19.  | blix.c - the main part of the blix program
  20.  |
  21.  |
  22.  |     (c) 1993 Frans van Hoesel, Xtreme graphics software
  23.  |    hoesel@chem.rug.nl
  24. */
  25.  
  26.  
  27.  
  28. #include <alloca.h>
  29. #include <math.h>
  30. #include <gl/gl.h>
  31. #include <gl/device.h>
  32. #include <gl/get.h>
  33. #include <gl/sphere.h>
  34. #include <gl/image.h>
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #include <unistd.h>
  39. #include <sys/types.h>
  40. #include <sys/stat.h>
  41. #include <fcntl.h>
  42.  
  43. #include "blix.h"
  44. #include "blixfont.h"
  45. #include "blixscore.h"
  46. #include "blixsound.h"
  47. #include "blixmenu.h"
  48. #include "blixui.h"
  49. #include "blixtexture.h"
  50. #include "bliximage.h"
  51. #include "blixscore_io.h"
  52. #include "config.h"
  53. #include "lod.h"
  54. #include "maze.h"
  55. #include "mymath.h"
  56. #include "players.h"
  57. #include "transparent.h"
  58. #include "IvtoGL.h"
  59.  
  60. int Lod = 2;
  61. int can_do_textures = 0;
  62. int notune = 0;
  63. int noworld = 0;
  64.  
  65. static float spinrot[4] = {0.0, 0.0, 0.0, 1.0};
  66. static float rvec[4] ; /* initialized in reset_transforms */
  67. static float trans[3];
  68. static int report_nodenum = FALSE;
  69. static int displmode;
  70. static int saved_displmode;
  71. static int zbuf = TRUE;
  72. static float mouse_clicked[3];
  73. static float y_pos;
  74. userinfo_t *inf;
  75. long zmin, zmax;
  76.  
  77. extern node_t *the_nodes;
  78. extern float trackpoint[3];
  79. extern float trackballsize;
  80. extern int mouse_dead;
  81.  
  82. float tb_project_to_sphere(const float r, const float x, const float y);
  83. int node_closest(float v[3], int nodenum, float mindist);
  84. int sginap(long);
  85.  
  86. void remember_view(float *, float *);
  87. void spin_draw(void);
  88. void do_menus(void);
  89. void draw_whatever(void);
  90. void set_perspective(void);
  91. void init_windows(void) ;
  92. void init_menus(void) ;
  93. void init_path(void) ;
  94. void build_matrix(void);
  95. void reset_rot(void);
  96.  
  97. /* from imagelib: */
  98. IMAGE *iopen();
  99. void getrow(IMAGE *, short *, int , int);
  100. void iclose(IMAGE *);
  101.  
  102. static float sphere_material[] = {
  103.             DIFFUSE, 0.795918, 0.273554, 0.00686136,
  104.             AMBIENT, 0.0, 0.0, 0.0,
  105.             SPECULAR, 0.48655, 0.319155, 0.444036,
  106.             SHININESS, 86,
  107.             EMISSION,  0.208082, 0.070142, 0.00175932,
  108.             ALPHA, 0.0,
  109.             LMNULL };
  110. static float sphere_material2[] = {
  111.             DIFFUSE, 0.495918, 0.053554, 0.00286136,
  112.             AMBIENT, 0.0, 0.0, 0.0,
  113.             SPECULAR, 0.48655, 0.319155, 0.444036,
  114.             SHININESS, 86,
  115.             EMISSION,  0.20, 0.030142, 0.00055932,
  116.             ALPHA, 0.0,
  117.             LMNULL };
  118. static float wall_material[] = {
  119.             DIFFUSE, 0.53, 0.14, 0.0039,
  120.             AMBIENT, 0, 0, 0,
  121.             EMISSION, 0.2, 0.14, 0.0017,
  122.             SPECULAR, 1, 0.991559, 0.963793,
  123.             SHININESS, 66,
  124.             ALPHA, 0.0,
  125.             LMNULL };
  126. static float darkwall_material[] = {
  127.             DIFFUSE, 0.53, 0.14, 0.0039,
  128.             AMBIENT, 0, 0, 0,
  129.             EMISSION, 0.2, 0.14, 0.0017,
  130.             SPECULAR, 0.1, 0.0991559, 0.0963793,
  131.             SHININESS, 66,
  132.             ALPHA, 0.0,
  133.             LMNULL };
  134. static float topwall_material[] = {
  135.             DIFFUSE, 0.14, 0.06, 0.31,
  136.             AMBIENT, 0, 0, 0,
  137.             EMISSION, 0.2, 0.14, 0.0017,
  138.             SPECULAR, 0.1, 0.0991559, 0.0963793,
  139.             SHININESS, 66,
  140.             ALPHA, 0.0,
  141.             LMNULL };
  142.  
  143. static float light1[] = {
  144.             POSITION, -1.0, 2.0, 1.0, 0.0,
  145.             LMNULL } ;
  146. static float light2[] = {
  147.             POSITION, 1.0, 2.0, -1.0, 0.0,
  148.             LCOLOR, 0.7, 1.0, 1.0,
  149.             AMBIENT, -0.2, -0.2, -0.2,
  150.             LMNULL } ;
  151. static float light3[] = {
  152.             POSITION, 0, 0.75, 0.0,
  153.             LMNULL };
  154.  
  155. static float light4[] = {
  156.             POSITION, 1.0, -2.0, 1.0, 0.0,
  157.             LMNULL } ;
  158. static float light0[] = {
  159.             LMNULL } ;
  160. static float lmodel[] = {
  161.             AMBIENT, 0.1, 0.1, 0.1,
  162.             LMNULL } ;
  163. static float lmodel0[] = {
  164.             LMNULL } ;
  165. static float material0[] = {
  166.             LMNULL } ;
  167. static float sphere[4] = { 0,0,0, 0.999};
  168.  
  169. Matrix rotmat;
  170. Matrix invrotmat;
  171. char *basename;
  172. char *datadir;
  173. int no_sfx = 1;
  174. int playing_tune = 0;
  175. int current_tune = 0;
  176. int display_scene = 1;
  177.  
  178.  
  179. /*__________________________________________________________________
  180.  |
  181.  | main 
  182. */
  183.  
  184. int main(int argc, char *argv[]) {
  185.     
  186.     char *m;
  187.     /* keep basename, for error messages */
  188.     basename = strdup( argv[0]);
  189.     if (strrchr(basename,'/') != NULL) {
  190.     basename = strrchr(basename,'/')+1;
  191.     }
  192.     if (argc >= 2) {
  193.     if (strcmp (argv[1],"-s") == NULL ||
  194.         strcmp(argv[argc-1], "-s") == NULL) {
  195.         notune = 1;
  196.     }
  197.     if (strcmp(argv[1], "-w") == NULL ||
  198.         strcmp(argv[argc-1], "-w") == NULL) {
  199.         noworld = 1;
  200.     }
  201.     }
  202.     init_path();
  203.     display_scene = INTRO;
  204.     init_tmpdir();
  205.     init_windows();
  206.     init_ui();
  207.     init_fonts();
  208.     draw_whatever2d();
  209.     no_sfx = init_sound();
  210.     current_tune = SFX_TUNE_A;
  211.     if (notune) {
  212.     toggle_tune();
  213.     toggle_tune();
  214.     } else {
  215.     /* the sleep makes things work as they should,
  216.      */
  217.     sleep(1);
  218.     sfx(SFX_WELCOME);
  219.     sleep(2);
  220.     toggle_tune();
  221.     playing_tune = 1;
  222.     sfx(current_tune);
  223.     }
  224.     init_server();
  225.     init_alpha();
  226.     init_maze();
  227.     init_menus();
  228.     init_players();
  229.     init_textures();
  230.     /* final brutal check for memory if this fails, then probably one of
  231.      * the unchecked mallocs failed too
  232.      */
  233.     m = (char *) malloc(200000);
  234.     if (m == NULL) {
  235.     fprintf(stderr, "%s: Not Enough Memory\n", basename);
  236.     exit_program();
  237.     }
  238.     free(m);
  239.     doscore(0);
  240.     gflush();
  241.     reset_transforms();
  242.     backface(TRUE);
  243.     lmdef(DEFMATERIAL, 1, sizeof(sphere_material), sphere_material);
  244.     lmdef(DEFMATERIAL, 2, sizeof(wall_material), wall_material);
  245.     lmdef(DEFMATERIAL, 3, sizeof(darkwall_material), darkwall_material);
  246.     lmdef(DEFMATERIAL, 4, sizeof(topwall_material), topwall_material);
  247.     lmdef(DEFMATERIAL, 5, sizeof(sphere_material2), sphere_material2);
  248.     lmdef(DEFMATERIAL, 10, sizeof(material0), material0);
  249.     lmdef(DEFLMODEL, 1, sizeof(lmodel), lmodel);
  250.     lmdef(DEFLMODEL, 10, sizeof(lmodel0), lmodel0);
  251.     lmdef(DEFLIGHT, 1, sizeof(light1), light1);
  252.     lmdef(DEFLIGHT, 2, sizeof(light2), light2);
  253.     lmdef(DEFLIGHT, 3, sizeof(light3), light3);
  254.     lmdef(DEFLIGHT, 4, sizeof(light4), light4);
  255.     lmdef(DEFLIGHT, 10, sizeof(light0), light0);
  256.     lmbind(LMODEL, 1);
  257.     lmbind(LIGHT0, 1);
  258.     if (Lod >= EXTRA_LIGHT )
  259.     lmbind(LIGHT1,2);
  260.     sphmode(SPH_TESS, SPH_OCT);
  261.     sphmode(SPH_HEMI, TRUE);
  262.     /* the next line may seem strange for speedy spheres
  263.      * but it saves a few micro seconds, because the matrix
  264.      * at the time of calling sphdraw, is always oriented
  265.      */
  266.     sphmode(SPH_ORIENT, FALSE);
  267.     sphmode(SPH_PRIM, SPH_MESH);
  268.     if (Lod >= EXTRA_FINE)
  269.     sphmode(SPH_DEPTH, 12);
  270.     else
  271.     sphmode(SPH_DEPTH, 11);
  272.     shademodel(GOURAUD);
  273.     build_maze(0, Lod);
  274.     reshapeviewport();
  275.     zbuffer(zbuf);
  276.     display_scene = GAME;
  277.     draw_whatever();
  278.     uimode = MODE3D;
  279.     start_full_menu();
  280.     ui();
  281.     exit_program();
  282.     return 0;
  283. }
  284.  
  285. void exit_program(void) {
  286.     tune_off();
  287.     sleep(1);
  288.     end_sound();
  289.     sginap(CLK_TCK/4);
  290.     gexit();
  291.     exit (0);
  292. }
  293.  
  294. /*___________________________________________________________________
  295.  | 
  296.  | init_path - find the path leading to the directory with blix data.
  297.  |
  298.  | the path to all the data files for blix is determined only once,
  299.  | by searching for the file blix.dat. (this file is used for nothing
  300.  | else; forget about its cryptic contents it's just a joke)
  301.  | specific testing is done for Indyzone path, and relative path
  302.  | on the developers CD, also DATADIR (defined at compile time),
  303.  | the current directory and the environment variable BLIXDIR are
  304.  | checked.
  305.  |
  306. */
  307.  
  308. void init_path(void) {
  309.     int f;
  310.     char fullpath[512];
  311.     
  312.     f = -1;
  313.     datadir = getenv("BLIXDIR");
  314.     if (datadir != NULL) {
  315.     strcpy(fullpath, datadir);
  316.     strcat(fullpath, "/blix.dat");
  317.     f = open(fullpath, O_RDONLY);
  318.     }
  319. #ifdef DATADIR 
  320.     if (f == -1) {
  321.     strcpy(fullpath, DATADIR);
  322.     strcat(fullpath, "/blix.dat");
  323.     f = open(fullpath, O_RDONLY);
  324.     }
  325. #endif
  326.     if (f == -1) {
  327.     strcpy(fullpath, "/usr/demos/IndiZone/.data/blix/blix.dat");
  328.     f = open(fullpath, O_RDONLY);
  329.     }
  330.     if (f == -1) {
  331.     strcpy(fullpath, "../data/blix/blix.dat");
  332.     f = open(fullpath, O_RDONLY);
  333.     }
  334.     if (f == -1) {
  335.     strcpy(fullpath, "./blix.dat");
  336.     f = open(fullpath, O_RDONLY);
  337.     }
  338.     if (f == -1) {
  339.     fprintf(stderr,"%s: unable to find blix.dat needed for running"
  340.         " blix.\n", basename);
  341.     exit(1);
  342.     }
  343.     close(f);
  344.     datadir = strdup(fullpath);
  345.     /* strip off the blix.dat part */
  346.     *(strrchr(datadir, '/')+1) = '\0';
  347. }
  348.  
  349. /*_________________________________________________________________
  350.  |
  351.  | remember_view -  is called from the ui routine.
  352.  |
  353.  | in t[0] I encode the operation to be done (pan/zoom); the
  354.  | parameters of the operation are in t[1] and t[2].
  355.  |
  356. */
  357.  
  358. void remember_view(float *r, float *t) {
  359.  
  360.     int nodenum;
  361.     
  362.     /* first time, switch to double buffered mode */
  363.     if (displmode == DMRGB) {
  364.     sfx(SFX_BEEP);
  365.     cpack(0x00000000);
  366.     clear();
  367.     gflush();
  368.     displmode = DMRGBDOUBLE;
  369.     doublebuffer();
  370.     gconfig();
  371.     gflush();
  372.     cpack(0x0000000);
  373.     if (zbuf) {
  374.         czclear(0x00000000, zmax);
  375.         swapbuffers();
  376.         czclear(0x00000000, zmax);
  377.         
  378.     } else {
  379.         clear();
  380.         swapbuffers();
  381.         clear();
  382.     }
  383.     }
  384.     /* t is an array of three floats, the first holds the 'command'
  385.      * the other two, the parameters; silly, but compatible.
  386.      */
  387.     if (t[0] == 0) {
  388.     /* 'pan' */
  389.     /* not really panning, just record the mouse position, and use
  390.      * that to guide blix around the maze.
  391.      */
  392.     mouse_clicked[0] = t[1];
  393.     mouse_clicked[1] = t[2];
  394.     trackpoint[0] = t[1];
  395.     trackpoint[1] = t[2] - y_pos;
  396.     trackpoint[2] = tb_project_to_sphere(trackballsize*1.005,
  397.         trackpoint[0], trackpoint[1]);
  398.     vtransform(trackpoint, invrotmat, trackpoint);
  399.     vnormal(trackpoint);
  400.     if (report_nodenum) {
  401.         nodenum = node_closest(trackpoint, -1, 0.0001);
  402.         if (nodenum >= 0) {
  403.         fprintf(stderr,"node %d: %f %f %f distance %f\n", nodenum, 
  404.             the_nodes[nodenum].pos[0],
  405.             the_nodes[nodenum].pos[1],
  406.             the_nodes[nodenum].pos[2],
  407.             vdistance(the_nodes[nodenum].pos, trackpoint));
  408.         }
  409.     }
  410.     add_quats(spinrot, rvec, rvec);
  411.     build_matrix();
  412.     } else if (t[0] == 1) {
  413.     /* zoom */
  414.     trans[2] += t[2]*6;
  415.     if (trans[2] > -1.1* SCALE)
  416.         trans[2] = -1.1 * SCALE;
  417.     trans[0] = 0;
  418.     /* zoom not only zooms in, but also translates a bit, so you
  419.      * don't zoom in via a straight line to the center, but via
  420.      * an exponential line towards a point above the pole
  421.      */
  422.     trans[1] = -1.8*exp(trans[2]/14)+0.662;        
  423.     if (trans[1] > 0) trans[1] = 0;
  424.     set_perspective();
  425.     spinrot[0] = 0;
  426.     spinrot[1] = 0;
  427.     spinrot[2] = 0;
  428.     spinrot[3] = 1;
  429.     } else if (t[0] == 2) {
  430.     /* Remember the rotation so we can spin... */
  431.     spinrot[0] = r[0];
  432.     spinrot[1] = r[1];
  433.     spinrot[2] = r[2];
  434.     spinrot[3] = r[3];
  435.     add_quats(r, rvec, rvec);    /* And add on more rotation */
  436.     build_matrix();
  437.     }
  438.     draw_whatever();    /* And draw the scene */
  439. }
  440.  
  441.  
  442. /*__________________________________________________________________
  443.  |
  444.  | switch_single - switch to single buffer RGB mode
  445.  |
  446.  | set the color to some color that looks appr. the same in both buffer
  447.  | modes, like cpack(0x00332244), or simply black or white.
  448.  | But set that color before you call this routine.
  449.  |
  450. */
  451.  
  452. void switch_single(void) {
  453.  
  454.     if (displmode == DMRGBDOUBLE ) {
  455.     displmode = DMRGB;
  456.     frontbuffer(TRUE);
  457.     clear();
  458.     frontbuffer(FALSE);
  459.     gflush();
  460.     singlebuffer();
  461.     gconfig();
  462.     }
  463.     
  464. }
  465.  
  466. /*___________________________________________________________________
  467.  |
  468.  | switch_double - switch to double buffer RGB mode
  469.  |
  470. */
  471.  
  472. void switch_double(void) {
  473.     
  474.     cpack(0x0000000);
  475.     if (displmode == DMRGB) {
  476.     clear();
  477.     gflush();
  478.     displmode = DMRGBDOUBLE;
  479.     doublebuffer();
  480.     gconfig();
  481.     gflush();
  482.     }
  483.     clear();
  484. }
  485.  
  486. /*__________________________________________________________________
  487.  |
  488.  | save_displaymode - save current display mode
  489.  |
  490. */
  491.  
  492. void save_displaymode(void) {
  493.     saved_displmode = displmode;
  494. }
  495.  
  496. /*__________________________________________________________________
  497.  |
  498.  | restore_displaymode - restore mode from saved state
  499.  |
  500. */
  501.  
  502. void restore_displaymode(void) {
  503.     if (displmode != saved_displmode) {
  504.     switch (saved_displmode) {
  505.       case DMRGBDOUBLE:
  506.         switch_double();
  507.         break;
  508.       case DMRGB:
  509.         switch_single();
  510.         break;
  511.     }
  512.     }
  513. } 
  514.  
  515.  
  516. /*__________________________________________________________________
  517.  |
  518.  | spin_draw - draw spinning world
  519.  |
  520. */
  521.  
  522. void spin_draw(void) {
  523.     /*
  524.      *    The ui_quiet flag is defined in "ui.h", and is
  525.      * kept up-to-date by the ui() routines.  When
  526.      * ui_quiet is FALSE, leave the object alone to let the
  527.      * user interact with it.
  528.      */
  529.     if (ui_quiet) {
  530.     if (displmode == DMRGB) {
  531.         sfx(SFX_BEEP);
  532.         cpack(0x00000000);
  533.         clear();
  534.         gflush();
  535.         displmode = DMRGBDOUBLE;
  536.         doublebuffer();
  537.         gconfig();
  538.         gflush();
  539.         cpack(0x0000000);
  540.         if (zbuf) {
  541.         czclear(0x00000000, zmax);
  542.         swapbuffers();
  543.         czclear(0x00000000, zmax);
  544.         
  545.         } else {
  546.         clear();
  547.         swapbuffers();
  548.         clear();
  549.         }
  550.     }
  551.         if (spinrot[0] != 0 || spinrot[1] != 0 || spinrot[2] != 0 
  552.         || spinrot[3] != 1) {
  553.         add_quats(spinrot, rvec, rvec); /* rotate again */
  554.         build_matrix();
  555.     }
  556.     draw_whatever();    /* And draw the scene */
  557.     }
  558. }
  559.  
  560.  
  561. extern int score;
  562. extern int highscore;
  563.  
  564. /* ARGSUSED */
  565. void draw_whatever(void) {
  566.     float val;
  567.     char *c;
  568.     char st[20];
  569.     float x, alph;
  570.     
  571.     zbuffer(zbuf);
  572.     switch (display_scene) {
  573.       case GAME:
  574.     pushmatrix();
  575.     if (mouse_dead) { 
  576.         sphere[3]+=0.008;
  577.         mouse_dead++;
  578.         if (sphere[3] > 1.2 && mouse_dead>60) {
  579.         sphere[3] = 0.999;
  580.         sleep(1);
  581.         mouse_dead = 0;
  582.         doscore(score);
  583.         score = 0;
  584.         switch_double();
  585.         zbuffer(zbuf);
  586.         reset_rot();
  587.         }
  588.     }
  589.     val = trans[2]*SCALE*TANFOVY;
  590.     ortho(val, -val, val, -val, NEAR, -trans[2] + EXTRA);
  591.     y_pos = trans[1]/(-val);
  592.     cpack(0x00000000);
  593.     if (zbuf) {
  594.         czclear(0x00000000, zmax);
  595.     } else {
  596.         clear();
  597.     }
  598.     translate(trans[0], trans[1], trans[2]);
  599.     players_action();
  600.     
  601.     if (Lod >= TEXTURE_MAPS && can_do_textures) {
  602.         lmbind(MATERIAL, 5);
  603.     } else {
  604.         lmbind(MATERIAL,1);
  605.     }
  606.     lmbind(LIGHT0,1);
  607.     sphdraw(sphere);
  608.     draw_maze(rotmat, zbuf);
  609.     draw_players(rotmat, invrotmat);
  610.     
  611.     popmatrix();
  612.     pushmatrix();
  613.     zbuffer(FALSE);
  614.     ortho2(-1,1, -1, 1);
  615.     if (mouse_dead > 5) {
  616.         /* draw a black square, but with appropiate alpha, so
  617.          * it the scene slowly fades away
  618.          */
  619.         alph = 1.0-(mouse_dead-5)/24.0;
  620.         if (alph < 0 ) {
  621.         alph = 0;
  622.         } else if (alph > 1.0) {
  623.         alph = 1.0;
  624.         }
  625.         set_alpha(alph);
  626.         cpack(0x00000000);
  627.         rectfi(-1, -1, 1, 1);
  628.         set_alpha(0);
  629.     }
  630.     sprintf(st, "%d",score);
  631.     c = st; 
  632.     x = -0.8;
  633.     while (*c) {
  634.         pushmatrix();
  635.         translate(x, -0.9, 0);
  636.         callobj(8000 + *c - '0');
  637.         popmatrix();
  638.         x+= 0.05;
  639.         c++;
  640.     }
  641.     if (highscore != 0) {
  642.         sprintf(st, "%d", highscore);
  643.         c = st; 
  644.         x = 0.70;
  645.         while (*c) {
  646.         pushmatrix();
  647.         translate(x, -0.9, 0);
  648.         callobj(8000 + *c - '0');
  649.         popmatrix();
  650.         x+= 0.05;
  651.         c++;
  652.         }
  653.         
  654.     }
  655.     if (mouse_dead) {
  656.         /* draw the word 'dead' (obj 7000), scale it so it grows
  657.          * and in the end make it fade away, by increasing alpha
  658.          */
  659.         x = mouse_dead/20.0+0.2;
  660.         if (x > 1.7) {
  661.         x = 1.7;
  662.         }
  663.         if (mouse_dead > 40 ) { 
  664.         alph = (mouse_dead-40)/20.0;
  665.         set_alpha(alph);
  666.         }
  667.         translate(0,0.4,0);
  668.         /*rotate((x-0.2)/1.5 * 3600, 'z');*/
  669.         scale(x,x,x);
  670.         callobj(7000);
  671.         set_alpha(0);
  672.     }
  673.     popmatrix();
  674.     if (displmode == DMRGBDOUBLE )
  675.         swapbuffers();    /* Show what we just drew */
  676.     break;
  677.       default:
  678.     /* something is wrong, but call draw_whatever2d to handle it */
  679.     printf("WRONG\n");
  680.     draw_whatever2d();
  681.  
  682.     }
  683. }
  684.  
  685. void draw_whatever2d(void) {
  686.     IMAGE *image;
  687.     char tmpstr[256];
  688.     int i;
  689.     float v1[3];
  690.     
  691.     zbuffer(FALSE);
  692.     subpixel(TRUE);
  693.     if (displmode == DMRGBDOUBLE ) {
  694.     switch_single();
  695.     clear();
  696.     gflush();
  697.     }
  698.     pushmatrix();
  699.     ortho2(0,1,0,1);
  700.     bgnpolygon();
  701.     v1[0] = 0; v1[1] = 1; cpack(0x000022bb);
  702.     v2f(v1);
  703.     v1[1] = 0; cpack(0x000061ff);
  704.     v2f(v1);
  705.     v1[0] = 1; cpack(0x000052ff);
  706.     v2f(v1);
  707.     v1[1] = 1; cpack(0x000038ff);
  708.     v2f(v1);
  709.     endpolygon();
  710.     switch (display_scene) {
  711.       case SORRY:
  712.     getsize(&sizey, &sizey);
  713.     ortho2(0, sizex, 0, sizey);
  714.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  715.     set_fontsize(0.075);
  716.     draw_stringXY(0.10, 0.9, "S O R R Y");
  717.     set_fontsize(0.060);
  718.     set_fontcolor(0x00b0b0, 0x00c0c0);
  719.     draw_stringXY(0.20, 0.72,
  720.         "For some reason Blix is\n"
  721.         "not able to connect to \n"
  722.         "the server that keeps\n"
  723.         "track of the highscores.\n\n\n"
  724.         "See the man page for\n"
  725.         "more details.");
  726.     gflush();
  727.     break;
  728.       case PAUSED:
  729.     strcpy(tmpstr, datadir);
  730.     strcat(tmpstr, "blixphoto.rgb");
  731.     image = iopen(tmpstr, "r");
  732.     if (image == NULL) {
  733.         fprintf(stderr,"%s: cannot locate photo image\n", basename);
  734.         exit_program();
  735.     }      
  736.     draw_image(image, 0.05, 0.25, 0.70, 0.90);
  737.     getsize(&sizey, &sizey);
  738.     ortho2(0, sizex, 0, sizey);
  739.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  740.     set_fontsize(0.20);
  741.     draw_stringXY(0.21, 0.63, " Game\nPaused");
  742.     set_fontsize(0.05);
  743.     draw_stringXY(0.37, 0.05, "Click mouse to continue...");
  744.     gflush();
  745.     break;
  746.       case INTRO:
  747.     strcpy(tmpstr, datadir);
  748.     strcat(tmpstr, "blixrt.rgb");
  749.     image = iopen(tmpstr, "r");
  750.     if (image == NULL) {
  751.         fprintf(stderr,"%s: cannot locate intro image\n", basename);
  752.         if (no_sfx == 0 )
  753.         end_sound();
  754.         gexit();
  755.         exit(1);
  756.     }      
  757.     ortho2(0, 1, 0, 1);
  758.     draw_image(image, 0.05, 0.50, 0.05, 0.85);
  759.     iclose(image);
  760.     getsize(&sizey, &sizey);
  761.     ortho2(0, sizex, 0, sizey);
  762.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  763.     set_fontsize(0.070);
  764.     draw_stringXY(0.60, 0.9, "WELCOME");
  765.     set_fontsize(0.050);
  766.     draw_stringXY(0.59, 0.82,
  767.         "My name is Blix.\n"
  768.         "I am the not too\n"
  769.         "undestructable\n"
  770.         "hero of this game.\n\n"
  771.         "Use the right\n"
  772.         "mousebutton to\n"
  773.         "popup the menu");
  774.     draw_stringXY(0.59, 0.26,
  775.         "Loading data...\n"
  776.         "Please wait.");
  777.     draw_stringXY(0.59, 0.13,
  778.         "Blix is written by\n"
  779.         "Frans van Hoesel\n");
  780.     zbuffer(zbuf);
  781.     gflush();
  782.     break;
  783.           
  784.      case PRIVATHIGH:
  785.     getsize(&sizex, &sizey);
  786.     inf = getinf();
  787.     ortho2(0, sizex, 0, sizey);
  788.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  789.     set_fontsize(0.078);
  790.     draw_stringXY(0.05, 0.92, "Y");
  791.     draw_stringXY(0.076, 0.92, "our personal highscores:");
  792.     sprintf(tmpstr,"after %d runs", (int)privatlist.game);
  793.     set_fontsize(0.043);
  794.     draw_stringXY(0.35, 0.85, tmpstr);
  795.     for (i=0; i< 7; i++) {
  796.         set_fontcolor((7.0-i)*0x202203, (7-i)*0x242400);
  797.         draw_stringXY(0.65, 0.77 - i * 0.1, privatlist.names[i]);
  798.         set_fontcolor((11.0-i)*0x111213, (11-i)*0x131313);
  799.         draw_stringXY(0.56, 0.77 - i * 0.1, "pts");
  800.     }
  801.     set_fontsize(0.053);
  802.     for (i=0; i<7; i++) {
  803.         set_fontcolor((7-i)*0x202000, (7-i)*0x242400);
  804.         sprintf(tmpstr, "%d", (int)privatlist.scores[i]);
  805.         draw_stringXY(0.55 - (strlen(tmpstr)* 0.032), 0.77 - i * 0.1, tmpstr);
  806.     }
  807.     set_fontcolor(0x05122d, 0x08102D);
  808.     draw_stringXY(0.05, 0.105, inf->name);
  809.     draw_stringXY(0.05, 0.04, inf->host);
  810.     image = NULL;
  811.     if (inf->image != NULL && *(inf->image) != '\0')
  812.         image = iopen(inf->image, "r");
  813.     if (image == NULL) {
  814.         strcpy(tmpstr, datadir);
  815.         strcat(tmpstr, "noimage.rgb");
  816.         image = iopen(tmpstr, "r");
  817.     }
  818.     if (image != NULL) {
  819.         draw_image(image, 0.05, 0.35, 0.50, 0.80);
  820.         iclose(image);
  821.     }
  822.     gflush();
  823.     break;
  824.       case SYSTEMHIGH:
  825.     getsize(&sizex, &sizey);
  826.     ortho2(0, sizex, 0, sizey);
  827.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  828.     set_fontsize(0.060);
  829.     draw_stringXY(0.04, 0.94, "The Best Players on your System:");
  830.     sprintf(tmpstr,"after %d runs", (int)systemlist.game);
  831.     set_fontsize(0.043);
  832.     draw_stringXY(0.35, 0.87, tmpstr);
  833.     for (i=0; i< 7; i++) {
  834.         set_fontcolor((7.0-i)*0x202203, (7-i)*0x242400);
  835.         if (systemlist.names[i] != NULL &&
  836.             *(systemlist.names[i]) != '\0') {
  837.         draw_stringXY(0.57, 0.74 - i * 0.1, systemlist.names[i]);
  838.         }
  839.         set_fontcolor(0x05122d, 0x08102D);
  840.         if (systemlist.hosts[i] != NULL &&
  841.             *(systemlist.hosts[i]) != '\0') {
  842.         strcpy(tmpstr,"(");
  843.         strcat(tmpstr, systemlist.hosts[i]);
  844.         strcat(tmpstr,")");
  845.         draw_stringXY(0.57, 0.69 - i * 0.1, tmpstr);
  846.         }
  847.         set_fontcolor((11.0-i)*0x111213, (11-i)*0x131313);
  848.         draw_stringXY(0.50, 0.74 - i * 0.1, "pts");
  849.     }
  850.     set_fontsize(0.053);
  851.     for (i=0; i<7; i++) {
  852.         set_fontcolor((7-i)*0x202000, (7-i)*0x242400);
  853.         sprintf(tmpstr, "%d", (int) systemlist.scores[i]);
  854.         draw_stringXY(0.49 - (strlen(tmpstr)* 0.032), 0.74 - i * 0.1, tmpstr);
  855.     }
  856.     for (i=0; i<7; i++) {
  857.         image = NULL;
  858.         if (systemlist.images[i] != NULL && *(systemlist.images[i]) != '\0')
  859.         image = iopen(systemlist.images[i], "r");
  860.         if (image == NULL) {
  861.         strcpy(tmpstr, datadir);
  862.         if (strncmp(systemlist.names[i], "Blix", 4) == NULL) {
  863.             strcat(tmpstr, "/blixphoto.rgb");
  864.         } else {
  865.             strcat(tmpstr, "/noimage.rgb");
  866.         }
  867.         image = iopen(tmpstr, "r");
  868.         }
  869.         if (image != NULL) {
  870.         draw_image(image,
  871.             0.18-(i&1)*0.16, 0.32-(i&1)*0.16, 0.683 - i*0.1, 0.823 - i*0.1);
  872.         iclose(image);
  873.         }
  874.     }
  875.     gflush();
  876.     break;
  877.       case WORLDHIGH:
  878.     getsize(&sizex, &sizey);
  879.     ortho2(0, sizex, 0, sizey);
  880.     set_fontcolor(0x0000A0A0, 0x00E0E0);
  881.     set_fontsize(0.060);
  882.     draw_stringXY(0.04, 0.94, "The Best Players of the World:");
  883.     sprintf(tmpstr,"after %d runs", (int) worldlist.game);
  884.     set_fontsize(0.043);
  885.     draw_stringXY(0.35, 0.87, tmpstr);
  886.     for (i=0; i< 7; i++) {
  887.         set_fontcolor((7.0-i)*0x202203, (7-i)*0x242400);
  888.         if (worldlist.names[i] != NULL &&
  889.             *(worldlist.names[i]) != '\0') {
  890.         draw_stringXY(0.57, 0.74 - i * 0.1, worldlist.names[i]);
  891.         }
  892.         set_fontcolor(0x05122d, 0x08102D);
  893.         if (worldlist.hosts[i] != NULL &&
  894.             *(worldlist.hosts[i]) != '\0') {
  895.         strcpy(tmpstr,"(");
  896.         strcat(tmpstr, worldlist.hosts[i]);
  897.         strcat(tmpstr,")");
  898.         draw_stringXY(0.57, 0.69 - i * 0.1, tmpstr);
  899.         }
  900.         set_fontcolor((11.0-i)*0x111213, (11-i)*0x131313);
  901.         draw_stringXY(0.50, 0.74 - i * 0.1, "pts");
  902.     }
  903.     set_fontsize(0.053);
  904.     for (i=0; i<7; i++) {
  905.         set_fontcolor((7-i)*0x202000, (7-i)*0x242400);
  906.         sprintf(tmpstr, "%d", (int) worldlist.scores[i]);
  907.         draw_stringXY(0.49 - (strlen(tmpstr)* 0.032), 0.74 - i * 0.1, tmpstr);
  908.     }
  909.     for (i=0; i<7; i++) {
  910.         image = NULL;
  911.         if (worldlist.images[i] != NULL && *(worldlist.images[i]) != '\0')
  912.         image = iopen(worldlist.images[i], "r");
  913.         if (image == NULL) {
  914.         strcpy(tmpstr, datadir);
  915.         if (strncmp(worldlist.names[i], "Blix", 4) == NULL) {
  916.             strcat(tmpstr, "/blixphoto.rgb");
  917.         } else {
  918.             strcat(tmpstr, "/noimage.rgb");
  919.         }
  920.         image = iopen(tmpstr, "r");
  921.         }
  922.         if (image != NULL) {
  923.         draw_image(image,
  924.             0.18-(i&1)*0.16, 0.32-(i&1)*0.16, 0.683 - i*0.1, 0.823 - i*0.1);
  925.         iclose(image);
  926.         }
  927.     }
  928.     gflush();
  929.     break;
  930.     }
  931.     popmatrix();
  932. }
  933.  
  934.  
  935. void reset_rot(void) {
  936.     rvec[0] = 0;
  937.     rvec[1] =0;
  938.     rvec[2] = 0;
  939.     rvec[3] = 1;
  940.     build_matrix();    
  941. }
  942.  
  943.  
  944. void build_matrix(void) {
  945.     build_rotmatrix(rotmat, rvec);
  946.     minvert(rotmat, invrotmat);
  947. }
  948.  
  949.  
  950. void reset_transforms(void) {
  951.     rvec[0] = rvec[1] = rvec[2] = 0.0;
  952.     rvec[3] = 1.0;
  953.     trans[0] = trans[1] = trans[2] = 0.0;
  954.     trans[2] = TRANS;
  955.     set_perspective();
  956.     build_matrix();
  957. }
  958.  
  959. void stop_spin(void) {
  960.     spinrot[0] = 0;
  961.     spinrot[1] = 0;
  962.     spinrot[2] = 0;
  963.     spinrot[3] = 1;
  964. }
  965.  
  966. void toggle_zbuf(void) {
  967.     zbuf =  !zbuf;
  968.     zbuffer(zbuf);
  969.     draw_whatever();
  970. }
  971.  
  972. void build_again(void) {
  973.     free_arcs();
  974.     init_maze();
  975.     build_maze(0, Lod);
  976.     draw_whatever();
  977. }
  978.  
  979.  
  980. void set_lod(int l) {
  981.     Lod = l-1;
  982.     free_arcs();
  983.     if (Lod >= EXTRA_LIGHT )
  984.     lmbind(LIGHT1,2);
  985.     else
  986.     lmbind(LIGHT1,0);
  987.     if (Lod >= EXTRA_FINE) {
  988.     sphmode(SPH_DEPTH, 12);
  989.     } else {
  990.     if (Lod >= WALLS_UP) {
  991.         sphmode(SPH_DEPTH, 10);
  992.     } else {
  993.         sphmode(SPH_DEPTH, 8);
  994.     }
  995.     }
  996.     shademodel(GOURAUD);
  997.     build_maze(0, Lod);
  998.     draw_whatever();
  999. }
  1000.  
  1001. void toggle_report(void) {
  1002.     report_nodenum = !report_nodenum;
  1003. }
  1004.  
  1005.  
  1006. void set_perspective(void) {
  1007.  
  1008.     static float t = TRANS;
  1009.     float   val;
  1010.     
  1011.     if (t == trans[2])
  1012.     return;
  1013.     val = trans[2]*SCALE*TANFOVY;
  1014.     /*ortho(val, -val,
  1015.         val, -val, NEAR, 
  1016.         -trans[2] + EXTRA);*/
  1017.     y_pos = trans[1]/(-val);
  1018.     set_trackball(1.0/(-val), y_pos);
  1019.     t = trans[2];
  1020. }
  1021.  
  1022.  
  1023.  
  1024. /*_________________________________________________________________________
  1025.  |
  1026.  | init_windows - initalize gl window
  1027.  |
  1028. */
  1029.  
  1030. void init_windows(void) {
  1031.     
  1032.     foreground();
  1033.     if (getgdesc(GD_BITS_NORM_DBL_RED) == 0 ||
  1034.         getgdesc(GD_BITS_NORM_DBL_GREEN) == 0 ||
  1035.         getgdesc(GD_BITS_NORM_DBL_BLUE) == 0) {
  1036.     fprintf(stderr, "Blix requires RGB mode which is not "
  1037.         "supported on your machine\n");
  1038.     exit (1);
  1039.     }
  1040.     if (getgdesc(GD_BITS_NORM_ZBUFFER) == 0) {
  1041.     fprintf(stderr, "Blix requires a zbuffer which is not "
  1042.         "supported on your machine\n");
  1043.     exit(1);
  1044.     }
  1045.     if (getgdesc(GD_SCRNTYPE) == GD_SCRNTYPE_NOWM) {
  1046.         prefposition(0, getgdesc(GD_YPMAX)/3-1,
  1047.                      0, getgdesc(GD_YPMAX)/3-1);
  1048.     } 
  1049.     minsize(300,300);
  1050.     winopen("blix");
  1051.     wintitle("blix (demo only)");
  1052.     icontitle("blix");
  1053.     keepaspect(1,1);
  1054.     minsize(100,100);
  1055.     winconstraints();
  1056.     RGBmode();
  1057.     displmode = DMRGBDOUBLE;
  1058.     doublebuffer();
  1059.     gconfig();
  1060.     chunksize(508);
  1061.     gflush();
  1062.     mmode(MVIEWING);
  1063.     zbuffer(TRUE);
  1064.     zmin = getgdesc(GD_ZMIN) & 0xffffff00;
  1065.     zmax = getgdesc(GD_ZMAX) & 0xffffff00;
  1066.     lsetdepth(zmin, zmax);
  1067.     cpack(0x00000000);
  1068.     czclear(0x00000000, zmax);
  1069.     subpixel(TRUE);
  1070.     can_do_textures = getgdesc(GD_TEXTURE);
  1071. }
  1072.  
  1073.